﻿using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Collections;
using System;


namespace Utility
{


    public class SQLHelper
    {

        #region 连接字符串
        /// <summary>
        /// 从Web.config中获得连接字符串
        /// </summary>
        public static readonly string connectionstring = ConfigurationManager.ConnectionStrings["ApplicationServices"].ConnectionString.ToString();
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public SQLHelper()
        {

        }
        #endregion

        #region GetConnection() 返回SqlConnection对象
        /// <summary>
        /// 连接数据库
        /// </summary>
        /// <returns>返回SqlConnection对象</returns>
        public static SqlConnection GetConnection()
        {
            string myStr = connectionstring;
            SqlConnection myConn = new SqlConnection(myStr);
            return myConn;
        }
        #endregion

        #region  ExecNonQuery(SqlCommand myCmd) 执行SQL语句，并返回受影响的行数
        /// <summary>
        /// 执行SQL语句，并返回受影响的行数
        /// </summary>
        /// <param name="myCmd">执行SQL语句命令的SqlCommand对象</param>
        public static void ExecNonQuery(SqlCommand myCmd)
        {
            try
            {
                if (myCmd.Connection.State != ConnectionState.Open)
                {
                    myCmd.Connection.Open(); //打开与数据库的连接
                }
                //使用SqlCommand对象的ExecuteNonQuery方法执行SQL语句，并返回受影响的行数
                myCmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }
            finally
            {
                if (myCmd.Connection.State == ConnectionState.Open)
                {
                    myCmd.Connection.Close(); //关闭与数据库的连接
                }
            }
        }
        #endregion

        #region ExecScalar(SqlCommand myCmd) 执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。
        /// <summary>
        /// 执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。 
        /// </summary>
        /// <param name="myCmd"></param>
        /// <returns>执行SQL语句命令的SqlCommand对象</returns>
        public string ExecScalar(SqlCommand myCmd)
        {
            string strSql;
            try
            {
                if (myCmd.Connection.State != ConnectionState.Open)
                {
                    myCmd.Connection.Open(); //打开与数据库的连接
                }
                //使用SqlCommand对象的ExecuteScalar方法执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。 

                strSql = Convert.ToString(myCmd.ExecuteScalar());
                return strSql;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }
            finally
            {
                if (myCmd.Connection.State == ConnectionState.Open)
                {
                    myCmd.Connection.Close();//关闭与数据库的连接
                }
            }
        }

        #endregion

        #region  GetDataSet(SqlCommand myCmd, string TableName) 返回数据集的表的集合
        /// <summary>
        /// 说  明：  返回数据集的表的集合
        ///	返回值：  数据源的数据表
        ///	参  数：  myCmd 执行SQL语句命令的SqlCommand对象，TableName 数据表名称
        /// </summary>
        public DataTable GetDataSet(SqlCommand myCmd, string TableName)
        {
            SqlDataAdapter adapt;
            DataSet ds = new DataSet();
            try
            {
                if (myCmd.Connection.State != ConnectionState.Open)
                {
                    myCmd.Connection.Open();
                }
                adapt = new SqlDataAdapter(myCmd);
                adapt.Fill(ds, TableName);
                return ds.Tables[TableName];

            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);

            }
            finally
            {
                if (myCmd.Connection.State == ConnectionState.Open)
                {
                    myCmd.Connection.Close();

                }
            }

        }

        #endregion

        #region GetCommandProc(string strProcName) 执行存储过程语句，返回sqlCommand类对象
        /// <summary>
        /// 执行存储过程语句，返回sqlCommand类对象
        /// </summary>
        /// <param name="strProcName">存储过程名</param>
        /// <returns>返回sqlCommand类对象</returns>
        public static SqlCommand GetCommandProc(string strProcName)
        {
            SqlConnection myConn = GetConnection();
            SqlCommand myCmd = new SqlCommand();
            myCmd.Connection = myConn;
            myCmd.CommandText = strProcName;
            myCmd.CommandType = CommandType.StoredProcedure;
            return myCmd;
        }
        #endregion




        #region GetCommandStr(string strSql) 执行查询语句，返回sqlCommand类对象
        /// <summary>
        /// 执行查询语句，返回sqlCommand类对象
        /// </summary>
        /// <param name="strSql">查询语句</param>
        /// <returns>返回sqlCommand类对象</returns>
        public SqlCommand GetCommandStr(string strSql)
        {
            SqlConnection myConn = GetConnection();
            SqlCommand myCmd = new SqlCommand();
            myCmd.Connection = myConn;
            myCmd.CommandText = strSql;
            myCmd.CommandType = CommandType.Text;
            return myCmd;
        }
        #endregion

        #region GetDataSetStr(string sqlStr, string TableName) 执行SQL语句，返回数据源的数据表
        /// <summary>
        /// 说  明：  执行SQL语句，返回数据源的数据表
        ///	返回值：  数据源的数据表DataTable
        ///	参  数：  sqlStr执行的SQL语句，TableName 数据表名称
        /// </summary>
        public static DataTable GetDataSetStr(string sqlStr, string TableName)
        {
            SqlConnection myConn = GetConnection();
            myConn.Open();
            DataSet ds = new DataSet();
            SqlDataAdapter adapt = new SqlDataAdapter(sqlStr, myConn);
            adapt.Fill(ds, TableName);
            myConn.Close();
            return ds.Tables[TableName];
        }
        #endregion


        #region AttachParameters 用于将所有必要的 SqlParameter 对象连接到正在运行的 SqlCommand

        //AttachParameters：该函数用于将所有必要的 SqlParameter 对象连接到正在运行的 SqlCommand。
        private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
        {
            SqlParameter[] parameterArray1 = commandParameters;
            for (int iNum1 = 0; iNum1 <= parameterArray1.Length - 1; iNum1++)
            {
                SqlParameter parameter1 = parameterArray1[iNum1];
                if (((parameter1.Direction == ParameterDirection.InputOutput) && (parameter1.Value == null)))
                {
                    parameter1.Value = DBNull.Value;
                }
                command.Parameters.Add(parameter1);
            }
        }

        #endregion

        #region AssignParameterValues：该函数用于为 SqlParameter 对象赋值
        //AssignParameterValues：该函数用于为 SqlParameter 对象赋值。 
        private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues)
        {
            if (((!(commandParameters == null)) && (!(parameterValues == null))))
            {
                if ((commandParameters.Length != parameterValues.Length))
                {
                    throw new ArgumentException("Parameter count does not match Parameter Value count.");
                }
                int iNum1 = 0;
                int iNum2 = commandParameters.Length;
                while ((iNum1 < iNum2))
                {
                    commandParameters[iNum1].Value = parameterValues[iNum1];
                    iNum1 += 1;
                }
            }
        }
        #endregion

        #region PrepareCommand：该函数用于对命令的属性（如连接、事务环境等）进行初始化
        //PrepareCommand：该函数用于对命令的属性（如连接、事务环境等）进行初始化。 
        private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters)
        {
            if ((connection.State != ConnectionState.Open))
            {
                connection.Open();
            }
            command.Connection = connection;
            command.CommandText = commandText;
            if ((!(transaction == null)))
            {
                command.Transaction = transaction;
            }
            command.CommandType = commandType;
            if ((!(commandParameters == null)))
            {
                AttachParameters(command, commandParameters);
            }
        }
        #endregion

        #region SqlDataReader

        #region ExecuteReader(string sql)
        /// <summary>
        /// ExecuteReader执行一查询，返回一SqlDataReader对象实例
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static SqlDataReader ExecuteReader(string sql)
        {
            return ExecuteReader(sql, CommandType.Text, null);
        }
        #endregion

        #region ExecuteReader(string sql, SqlParameter[] parameters)
        /// <summary>
        ///  ExecuteReader执行一查询，返回一SqlDataReader对象实例
        /// </summary>
        /// <param name="sql">查询语句</param>
        /// <param name="parameters">参数数组</param>
        /// <returns></returns>
        public static SqlDataReader ExecuteReader(string sql, SqlParameter[] parameters)
        {
            return ExecuteReader(sql, CommandType.Text, parameters);
        }
        #endregion

        #region ExecuteReader(string sql, CommandType commandType)
        /// <summary>
        /// ExecuteReader执行一查询，返回一SqlDataReader对象实例
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static SqlDataReader ExecuteReader(string sql, CommandType commandType)
        {
            return ExecuteReader(sql, commandType, null);
        }
        #endregion

        #region ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
        /// <summary>
        /// ExecuteReader执行一查询，返回一SqlDataReader对象实例
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <param name="parameters">参数数组 </param>
        /// <returns> </returns>
        public static SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            SqlConnection connection = new SqlConnection(connectionstring);
            SqlCommand command = new SqlCommand(sql, connection);
            command.CommandType = commandType;
            if (parameters != null)
            {
                // AttachParameters(command, parameters);
                foreach (SqlParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }
            connection.Open();
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }
        #endregion
    
    #endregion

        #region ExecuteNonQuery

        #region ExecuteNonQuery(string sql)
        /// <summary>
        /// ExecuteNonQuery操作，对数据库进行 增、删、改 操作
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static int ExecuteNonQuery(string sql)
        {
            return ExecuteNonQuery(sql, CommandType.Text, null);
        }
        #endregion

        #region ExecuteNonQuery(string sql, SqlParameter[] parameter)
        /// <summary>
        /// ExecuteNonQuery操作，对数据库进行 增、删、改 操作
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static int ExecuteNonQuery(string sql, SqlParameter[] parameter)
        {
            return ExecuteNonQuery(sql, CommandType.Text, parameter);
        } 
        #endregion

        #region ExecuteNonQuery(string sql, CommandType commandType)
        /// <summary>
        /// ExecuteNonQuery操作，对数据库进行 增、删、改 操作（2）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static int ExecuteNonQuery(string sql, CommandType commandType)
        {
            return ExecuteNonQuery(sql, commandType, null);
        } 
        #endregion

        #region ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)
        /// <summary>
        /// ExecuteNonQuery操作，对数据库进行 增、删、改 操作（3）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <param name="parameters">参数数组 </param>
        /// <returns> </returns>
        public static int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            int count = 0;
         

            using (SqlConnection connection = new SqlConnection(connectionstring))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();
                    count = command.ExecuteNonQuery();
                }
            }
            return count;
        } 
        #endregion


        #endregion

        #region SqlDataAdapter
        #region ExecuteDataSet(string sql)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataSet类型结果（1）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static DataSet ExecuteDataSet(string sql)
        {
            return ExecuteDataSet(sql, CommandType.Text, null);
        }
        #endregion

        #region ExecuteDataSet(string sql, CommandType commandType)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataSet类型结果（2）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static DataSet ExecuteDataSet(string sql, CommandType commandType)
        {
            return ExecuteDataSet(sql, commandType, null);
        }
        #endregion

        #region ExecuteDataSet(string sql, CommandType commandType, SqlParameter[] parameters)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataSet类型结果（3）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <param name="parameters">参数数组 </param>
        /// <returns> </returns>
        public static DataSet ExecuteDataSet(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            DataSet ds = new DataSet();
            using (SqlConnection connection = new SqlConnection(connectionstring))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    SqlDataAdapter adapter = new SqlDataAdapter(command);
                    adapter.Fill(ds);
                }
            }
            return ds;
        }
        #endregion

        #region ExecuteDataTable(string sql)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataTable类型结果（1）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static DataTable ExecuteDataTable(string sql)
        {
            return ExecuteDataTable(sql, CommandType.Text, null);
        }
        #endregion

        #region ExecuteDataTable(string sql, CommandType commandType)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataTable类型结果（2）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static DataTable ExecuteDataTable(string sql, CommandType commandType)
        {
            return ExecuteDataTable(sql, commandType, null);
        }
        #endregion


        #region ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
        /// <summary>
        /// SqlDataAdapter的Fill方法执行一个查询，并返回一个DataTable类型结果（3）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <param name="parameters">参数数组 </param>
        /// <returns> </returns>
        public static DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            DataTable data = new DataTable();
            using (SqlConnection connection = new SqlConnection(connectionstring))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    SqlDataAdapter adapter = new SqlDataAdapter(command);
                    adapter.Fill(data);
                }
            }
            return data;
        }
        #endregion
        #endregion

        #region ExecuteScalar
        #region ExecuteScalar(string sql)
        /// <summary>
        /// ExecuteScalar执行一查询，返回查询结果的第一行第一列（1）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <returns> </returns>
        public static Object ExecuteScalar(string sql)
        {
            return ExecuteScalar(sql, CommandType.Text, null);
        }
        #endregion

        #region ExecuteScalar(string sql, CommandType commandType)
        /// <summary>
        /// ExecuteScalar执行一查询，返回查询结果的第一行第一列（2）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static Object ExecuteScalar(string sql, CommandType commandType)
        {
            return ExecuteScalar(sql, commandType, null);
        }
        #endregion

        public static Object ExecuteScalar(string sql,SqlParameter[] parameters)
        {
            return ExecuteScalar(sql,CommandType.Text,parameters);
        }


        #region ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)
        /// <summary>
        /// ExecuteScalar执行一查询，返回查询结果的第一行第一列（3）
        /// </summary>
        /// <param name="sql">要执行的SQL语句 </param>
        /// <param name="commandType">要执行的查询类型（存储过程、SQL文本） </param>
        /// <returns> </returns>
        public static Object ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            object result = null;
            using (SqlConnection connection = new SqlConnection(connectionstring))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();
                    result = command.ExecuteScalar();
                }
            }
            return result;
        }
        #endregion
        #endregion

        #region GetTables() 返回当前连接的数据库中所有由用户创建的数据库
        /// <summary>
        /// 返回当前连接的数据库中所有由用户创建的数据库
        /// </summary>
        /// <returns> </returns>
        public static DataTable GetTables()
        {
            DataTable data = null;
            using (SqlConnection connection = new SqlConnection(connectionstring))
            {
                connection.Open();
                data = connection.GetSchema("Tables");
            }
            return data;
        } 
        #endregion



        public static DataTable generateDataTable(string cmd,string []columnName)
        {
            DataTable data = new DataTable();
            SqlDataReader sdReader = ExecuteReader(cmd);

            for (int i = 0; i < columnName.Length;i++ )
            {
                data.Columns.Add(columnName[i]);
            }
            DataRow row;
            while (sdReader.Read())
            {
                row = data.NewRow();
                for (int i = 0; i < columnName.Length; i++)
                {
                    row[i] = sdReader[columnName[i]].ToString();
                }
                data.Rows.Add(row);
            }
            sdReader.Close();
            return data;
        }
    }
}
